const { ApiKey } = require('../models');

/**
 * API密钥服务类
 * 提供获取和管理API密钥的功能
 */
class ApiKeyService {
  
  /**
   * 根据提供商获取可用的API密钥
   * @param {string} provider - API提供商
   * @returns {Promise<string|null>} 解密后的API密钥
   */
  static async getKeyByProvider(provider) {
    try {
      if (!provider || provider.trim() === '') {
        throw new Error(`无效的API提供商: ${provider}`);
      }

      const apiKey = await ApiKey.getActiveKeyByProvider(provider);
      return apiKey;
    } catch (error) {
      console.error(`获取${provider} API密钥失败:`, error);
      return null;
    }
  }

  /**
   * 获取OpenAI API密钥
   * @returns {Promise<string|null>}
   */
  static async getOpenAIKey() {
    return await this.getKeyByProvider('openai');
  }

  /**
   * 获取Claude API密钥
   * @returns {Promise<string|null>}
   */
  static async getClaudeKey() {
    return await this.getKeyByProvider('claude');
  }

  /**
   * 获取Gemini API密钥
   * @returns {Promise<string|null>}
   */
  static async getGeminiKey() {
    return await this.getKeyByProvider('gemini');
  }

  /**
   * 获取DeepSeek API密钥
   * @returns {Promise<string|null>}
   */
  static async getDeepSeekKey() {
    return await this.getKeyByProvider('deepseek');
  }

  /**
   * 获取火山引擎 API密钥
   * @returns {Promise<string|null>}
   */
  static async getVolcengineKey() {
    return await this.getKeyByProvider('volcengine');
  }

  /**
   * 获取所有可用的API密钥概览
   * @returns {Promise<Object>} 按提供商分组的密钥信息
   */
  static async getAllActiveKeys() {
    try {
      return await ApiKey.getAllActiveKeys();
    } catch (error) {
      console.error('获取所有API密钥失败:', error);
      return {};
    }
  }

  /**
   * 检查指定提供商是否有可用的API密钥
   * @param {string} provider - API提供商
   * @returns {Promise<boolean>}
   */
  static async hasActiveKey(provider) {
    try {
      const key = await this.getKeyByProvider(provider);
      return key !== null;
    } catch (error) {
      console.error(`检查${provider}密钥可用性失败:`, error);
      return false;
    }
  }

  /**
   * 获取密钥使用统计
   * @param {string} provider - API提供商（可选）
   * @returns {Promise<Object>} 使用统计信息
   */
  static async getUsageStats(provider = null) {
    try {
      const whereClause = provider ? { provider, is_active: true } : { is_active: true };
      
      const keys = await ApiKey.findAll({
        where: whereClause,
        attributes: ['id', 'name', 'provider', 'usage_count', 'last_used_at'],
        order: [['usage_count', 'DESC']]
      });

      const stats = {
        total_keys: keys.length,
        total_usage: keys.reduce((sum, key) => sum + key.usage_count, 0),
        by_provider: {}
      };

      // 按提供商分组统计
      keys.forEach(key => {
        if (!stats.by_provider[key.provider]) {
          stats.by_provider[key.provider] = {
            count: 0,
            usage: 0,
            keys: []
          };
        }
        
        stats.by_provider[key.provider].count++;
        stats.by_provider[key.provider].usage += key.usage_count;
        stats.by_provider[key.provider].keys.push({
          id: key.id,
          name: key.name,
          usage_count: key.usage_count,
          last_used_at: key.last_used_at
        });
      });

      return stats;
    } catch (error) {
      console.error('获取使用统计失败:', error);
      return {
        total_keys: 0,
        total_usage: 0,
        by_provider: {}
      };
    }
  }

  /**
   * 轮询获取最少使用的API密钥
   * @param {string} provider - API提供商
   * @returns {Promise<string|null>}
   */
  static async getLeastUsedKey(provider) {
    try {
      const apiKeyRecord = await ApiKey.findOne({
        where: {
          provider: provider,
          is_active: true
        },
        order: [['usage_count', 'ASC'], ['last_used_at', 'ASC']]
      });

      if (apiKeyRecord) {
        // 更新使用统计
        await apiKeyRecord.updateUsage();
        return apiKeyRecord.getDecryptedKey();
      }

      return null;
    } catch (error) {
      console.error(`获取${provider}最少使用密钥失败:`, error);
      return null;
    }
  }

  /**
   * 验证API密钥格式
   * @param {string} provider - API提供商
   * @param {string} apiKey - API密钥
   * @returns {boolean} 是否格式正确
   */
  static validateKeyFormat(provider, apiKey) {
    if (!apiKey || typeof apiKey !== 'string') {
      return false;
    }

    switch (provider.toLowerCase()) {
      case 'openai':
        // OpenAI密钥通常以sk-开头
        return apiKey.startsWith('sk-') && apiKey.length > 20;
      
      case 'claude':
        // Claude密钥格式验证
        return apiKey.length > 20;
      
      case 'gemini':
        // Gemini密钥格式验证
        return apiKey.length > 20;
      
      default:
        // 其他类型密钥的基本验证
        return apiKey.length > 10;
    }
  }

  /**
   * 获取密钥的掩码版本（用于显示）
   * @param {string} apiKey - 原始API密钥
   * @returns {string} 掩码后的密钥
   */
  static maskApiKey(apiKey) {
    if (!apiKey || apiKey.length < 8) {
      return '****';
    }
    
    const start = apiKey.substring(0, 4);
    const end = apiKey.substring(apiKey.length - 4);
    const middle = '*'.repeat(Math.max(4, apiKey.length - 8));
    
    return `${start}${middle}${end}`;
  }
}

module.exports = ApiKeyService;
